import axios from "axios";

const instance = axios.create({
  baseURL: "http://www.hcsy.asia:8080",
  // baseURL: "http://localhost:8080",
  timeout: 30000, // 普通接口超时时间: 30秒
});

// 请求拦截器，自动携带 token
instance.interceptors.request.use((config) => {
  const token = localStorage.getItem("token");
  if (token) {
    config.headers.Authorization = `${token}`;
  }
  return config;
});

// 响应拦截器，遇到 401 自动跳转登录页
instance.interceptors.response.use(
  (response) => response,
  (error) => {
    if (
      error.response &&
      error.response.status === 401 &&
      typeof window !== "undefined"
    ) {
      // 清除本地 token 和用户信息
      localStorage.removeItem("token");
      localStorage.removeItem("userId");
      localStorage.removeItem("username");
      localStorage.removeItem("userRole");
      // 跳转登录页
      if (window.location.pathname !== "/login") {
        window.location.href = "/login";
      }
    }
    return Promise.reject(error);
  }
);

// 通用的响应处理中间件
export function handleApiResponse(response, defaultErrorMessage = "操作失败") {
  if (response.code === 0) {
    throw new Error(response.msg || defaultErrorMessage);
  }
  return response;
}

// 基础请求方法
export function request({
  url,
  method = "get",
  data = {},
  params = {},
  timeout,
}) {
  const config = {
    url,
    method,
    data,
    params,
  };

  // 如果传入了timeout参数，则覆盖默认超时时间
  if (timeout) {
    config.timeout = timeout;
  }

  return instance(config).then((res) => res.data);
}

// 带错误处理的请求方法
export function requestWithErrorHandling({
  url,
  method = "get",
  data = {},
  params = {},
  timeout,
  errorMessage = "操作失败",
}) {
  return request({ url, method, data, params, timeout }).then((res) =>
    handleApiResponse(res, errorMessage)
  );
}

// 统一的401错误处理逻辑
function handle401Error() {
  localStorage.removeItem("token");
  localStorage.removeItem("userId");
  localStorage.removeItem("username");
  localStorage.removeItem("userRole");
  if (typeof window !== "undefined" && window.location.pathname !== "/login") {
    window.location.href = "/login";
  }
}

// 获取流式请求的统一配置
function getStreamRequestConfig(customConfig = {}) {
  const token = localStorage.getItem("token");
  const baseURL = customConfig.baseURL || instance.defaults.baseURL;
  const timeout = customConfig.timeout || 300000; // 默认5分钟

  return {
    baseURL,
    timeout,
    headers: {
      "Content-Type": "application/json",
      Authorization: token ? `${token}` : "",
      ...customConfig.headers,
    },
  };
}

// 基础流式请求方法
export async function streamRequest({
  url,
  method = "POST",
  data = {},
  onMessage,
  onError,
  onComplete,
  config = {},
}) {
  const requestConfig = getStreamRequestConfig(config);

  // 创建AbortController用于超时控制
  const controller = new AbortController();
  const totalTimeoutId = setTimeout(() => {
    controller.abort();
  }, requestConfig.timeout);

  // 数据空闲超时配置（默认30秒没有数据就结束）
  const idleTimeout = config.idleTimeout || 30000;
  const serviceName = config.serviceName || "AI服务"; // 添加服务名称用于日志
  let idleTimeoutId = null;
  let isIdleTimeout = false; // 标记是否是空闲超时

  // 重置空闲计时器
  const resetIdleTimeout = () => {
    if (idleTimeoutId) {
      clearTimeout(idleTimeoutId);
    }
    idleTimeoutId = setTimeout(() => {
      console.log(
        `${serviceName} 流式响应空闲超时 (${idleTimeout}ms)，自动结束`
      );
      isIdleTimeout = true; // 标记为空闲超时
      controller.abort();
    }, idleTimeout);
  };

  try {
    const response = await fetch(`${requestConfig.baseURL}${url}`, {
      method,
      headers: requestConfig.headers,
      body: JSON.stringify(data),
      signal: controller.signal,
    });

    // 统一错误处理 - 检查HTTP状态
    if (!response.ok) {
      if (response.status === 401) {
        handle401Error();
        throw new Error("登录已过期，请重新登录");
      }
      throw new Error(`请求失败: ${response.status} ${response.statusText}`);
    }

    const reader = response.body.getReader();
    const decoder = new TextDecoder();
    let buffer = "";

    // 启动空闲计时器
    resetIdleTimeout();

    while (true) {
      const { done, value } = await reader.read();

      if (done) {
        console.log("流式响应读取完成，正常结束");
        clearTimeout(totalTimeoutId);
        if (idleTimeoutId) clearTimeout(idleTimeoutId);
        // 读取完成时调用 onComplete
        onComplete && onComplete({ message: "", finished: true });
        break;
      }

      // 收到数据，重置空闲计时器
      resetIdleTimeout();

      buffer += decoder.decode(value, { stream: true });

      // 处理可能包含多个data行的情况
      const lines = buffer.split("\n");
      buffer = lines.pop(); // 保留最后一个不完整的行

      for (const line of lines) {
        if (line.trim() === "") continue;

        if (line.startsWith("data: ")) {
          try {
            const jsonStr = line.slice(6); // 移除 "data: " 前缀
            const streamData = JSON.parse(jsonStr);

            console.log("收到流式数据:", streamData); // 调试日志

            // 统一响应格式处理 - 检查业务状态码
            if (streamData.code === 0) {
              throw new Error(
                streamData.msg || config.errorMessage || "流式响应处理失败"
              );
            }

            if (streamData.code === 1 && streamData.data) {
              // 先发送消息内容
              onMessage && onMessage(streamData.data);

              // 检查是否为结束标记（Coze服务的结束标记）
              if (
                streamData.data.message &&
                streamData.data.message.includes(
                  '{"msg_type":"generate_answer_finish"'
                )
              ) {
                console.log("检测到 Coze 结束标记，流式响应完成");
                clearTimeout(totalTimeoutId);
                if (idleTimeoutId) clearTimeout(idleTimeoutId);
                onComplete && onComplete(streamData.data);
                break;
              }
              // 检查 Gemini 服务的结束标记
              else if (
                streamData.data.finish_reason === "stop" ||
                streamData.data.finished === true ||
                (streamData.data.message &&
                  streamData.data.message.trim().endsWith("[DONE]"))
              ) {
                console.log("检测到 Gemini 结束标记，流式响应完成");
                clearTimeout(totalTimeoutId);
                if (idleTimeoutId) clearTimeout(idleTimeoutId);
                onComplete && onComplete(streamData.data);
                break;
              }
              // 检查是否是最后一个数据包（通用检查）
              else if (
                streamData.data.is_final === true ||
                streamData.data.done === true
              ) {
                console.log("检测到通用结束标记，流式响应完成");
                clearTimeout(totalTimeoutId);
                if (idleTimeoutId) clearTimeout(idleTimeoutId);
                onComplete && onComplete(streamData.data);
                break;
              }
            }
          } catch (parseError) {
            console.warn("解析流式数据失败:", parseError, "Line:", line);
            // 不中断流式处理，继续处理下一行
          }
        }
      }
    }
  } catch (error) {
    clearTimeout(totalTimeoutId);
    if (idleTimeoutId) clearTimeout(idleTimeoutId);
    console.error("流式请求失败:", error);

    // 如果是空闲超时，调用 onComplete 而不是 onError
    if (isIdleTimeout && error.name === "AbortError") {
      console.log(`${serviceName} 空闲超时，正常结束对话`);
      // 传递一个标记，表示是因为空闲超时结束的
      onComplete && onComplete({ message: "", idleTimeout: true }); // 调用完成回调
      return;
    }

    // 统一错误处理和提示
    let errorMessage = config.errorMessage || "流式请求失败";
    if (error.name === "AbortError") {
      errorMessage = "请求超时，AI生成时间较长，请稍后重试";
    } else if (error.message) {
      if (error.message.includes("登录")) {
        errorMessage = error.message;
      } else if (
        error.message.includes("网络") ||
        error.message.includes("Failed to fetch")
      ) {
        errorMessage = "网络连接失败，请检查网络";
      } else {
        errorMessage = error.message;
      }
    }

    onError && onError(new Error(errorMessage));
  }
}

// 带错误处理的流式请求方法
export async function streamRequestWithErrorHandling({
  url,
  method = "POST",
  data = {},
  onMessage,
  onError,
  onComplete,
  config = {},
  errorMessage = "流式请求失败",
}) {
  return streamRequest({
    url,
    method,
    data,
    onMessage,
    onError: (error) => {
      // 可以在这里添加全局错误处理逻辑
      console.error("流式请求错误:", error);
      onError && onError(error);
    },
    onComplete,
    config: {
      ...config,
      errorMessage,
    },
  });
}

// spring服务测试接口
export function getSpringTest() {
  return request({ url: "/api_spring/spring", method: "get" });
}

// 导出axios实例
export { instance };
